home
***
CD-ROM
|
disk
|
FTP
|
other
***
search
/
FishMarket 1.0
/
FishMarket v1.0.iso
/
fishies
/
476-500
/
disk_500
/
wiconify
/
wiconify-source.lzh
/
Source
/
wFile.c
< prev
next >
Wrap
C/C++ Source or Header
|
1991-04-19
|
15KB
|
562 lines
/*
* WICONIFY A utility that allows you to iconify any Intuition window
* on any screen, and to open WB windows on any screen.
*
* wFile.c Reads the initialization file.
*
* Copyright 1990 by Davide P. Cervone, all rights reserved.
* You may use this code, provided this copyright notice is kept intact.
*/
#include "wFile.h"
USHORT ImageData[MAXWORDS][MAXHEIGHT][MAXDEPTH]; /* Images are read here */
short MaxWidth,MaxHeight,MaxWords; /* Current size of image */
UBYTE Plane0,Plane1; /* Bitplanes used */
int ImageType; /* Image, Select, or Mask */
int IconFileOpen; /* TRUE when file is open */
static int ScreenCount; /* How many screens to ignore */
static short ColorID; /* Which screen color is next */
static short BitMapLine; /* Which image line is next */
static int NoMenus; /* TRUE if no menus defined */
extern char **ComName; /* Current command table */
extern int AutoResize; /* TRUE if windows are sized to fit */
extern int IconifyPriority, /* Process priority of handler */
HandlerPriority; /* Priority in Input Handler chain */
/*
* ClearBitMap()
*
* Set each word to zero, and clear the dimensions, bitplane counters
* and line count.
*/
static void ClearBitMap()
{
short i,j,k;
for (i=0; i<MAXWORDS; i++)
for (j=0; j<MAXHEIGHT; j++)
for (k=0; k<MAXDEPTH; k++)
ImageData[i][j][k] = 0;
MaxWidth = MaxHeight = MaxWords = 0;
Plane0 = 0xFF; Plane1 = 0x00;
BitMapLine = 0;
}
/*
* SetImage()
*
* Set the PlanePick and PlaneOnOff values according to which planes have
* zeros and which have ones (if a plane is all zero or all one it can
* use PlaneOnOff and be excluded from PlanePick).
*
* Get a new Image structure (report an error if out of memory)
* Count the number of planes of data (the number of 1's in PlanePick).
* Set the Image fields.
* If there are any planes of data
* Allocate enough CHIP memory for them,
* If successful,
* Set the ImageData pointer,
* For each plane in the image,
* if the plane is one of the picked planes,
* copy the values of the image data for that plane
* Otherwise, report a memory error, and free the image structure
*/
static void SetImage(theImage)
struct Image **theImage;
{
short i,j,k;
UBYTE PlanePick = (~Plane0 & Plane1) | (Plane0 & ~Plane1);
UBYTE PlaneOnOff = Plane0 & Plane1;
short Depth = 0;
UWORD *theWord;
if (NEWSTRUCT(Image,*theImage))
{
for (k=PlanePick; k; k>>=1) if (k & 1) Depth++;
(*theImage)->PlanePick = PlanePick;
(*theImage)->PlaneOnOff = PlaneOnOff;
(*theImage)->Width = MaxWidth;
(*theImage)->Height = MaxHeight;
(*theImage)->Depth = Depth;
if (Depth)
{
theWord = AllocRaster(MaxWidth,MaxHeight*Depth);
if (theWord)
{
(*theImage)->ImageData = theWord;
for (k=0; k<MAXDEPTH; k++)
{
if (PlanePick & (1<<k))
{
for (j=0; j<MaxHeight; j++)
for (i=0; i<MaxWords; i++)
*theWord++ = ImageData[i][j][k];
}
}
} else {
ShowError("Can't get CHIP memory for Image");
FREESTRUCT(Image,*theImage);
*theImage = NULL;
}
}
} else ShowError("Can't get memory for Image structure");
}
/*
* StartCommand()
*
* Set up anything needed to begin the specified command. Usually this
* means clear any previous value of the appropriate variables or flags,
* and possibly recording the command type for future reference.
*/
static void StartCommand(theCommand)
int theCommand;
{
switch(theCommand)
{
case COM_ICONKEY:
IconifyKey = 0;
IconifyQuals = IconifyDisquals = 0;
break;
case COM_CHANGEREFRESH:
IconifyChange = 0;
break;
case COM_ACTIVEKEY:
ActivateKey = 0;
ActivateQuals = 0;
break;
case COM_COLORMAP:
ColorID = 0;
break;
case COM_IGNORESCREEN:
ScreenCount = 0;
break;
case COM_DEFAULTFLAGS:
DefaultFlags = 0;
break;
case COM_SCREENFLAGS:
DefaultScreenFlags = 0;
break;
case COM_MENUKEYS:
NoMenus = TRUE;
break;
case COM_DEFAULTIMAGE:
case COM_DEFAULTSELECT:
case COM_DEFAULTMASK:
case COM_SCREENIMAGE:
case COM_SCREENSELECT:
case COM_SCREENMASK:
ClearBitMap();
ImageType = theCommand;
break;
}
}
/*
* ContinueCommand()
*
* Do the right thing for each kind of command:
*
* ICONKEY:
* Read the next part of a key definition allowing qualifiers,
* disqualifiers, and a key name. If a key name was given, then
* it must be the last thing on the line, and the command is over.
*
* CHANGEREFRESH:
* Read the next part of a key definition allowing only qualifiers
* Keep reading until the next command is read.
*
* ACTIVEKEY:
* Read the next part of a key definition allowing qualifiers or a
* key name. If a key name, it must be the last thing on the line,
* and the command is complete.
*
* COLORMAP:
* Read the next color in the map.
*
* DEFAULTFLAGS:
* SCREENFLAGS:
* Read the next flag. Keep reading until the next command is read.
*
* MENUKEYS:
* Read the next menu key equivalent, and indicate that menus have
* been processed.
*
* IGNORESCREEN:
* Get the title of the screen to ignore, and count the screen.
* Read additional screen until the next command is read.
*
* PRIORITY:
* Get the process priority and check that it is a legal value.
* End the command.
*
* HIRESCLICOM:
* Get the CLI command string, and end the command.
*
* LORESCLI:
* Get the CLI command string, and end the command.
*
* COMMANDSTACK:
* Read the stack size for the CLI command, and check that it is
* not too small (report an error if it is, and set it to the minimum).
* End the command.
*
* IMAGE, SELECT, or MASK:
* Read the next line of the image.
*
* DEFAULTICON:
* SCREENICON:
* Open an Icon file for processing, and end the command (the next
* command will come from the file).
*
* OPENON:
* Get the OpenOn menu type and end the command.
*
* AUTORESIZE:
* Get the resize flag and end the command.
*
* HANDLERPRI:
* Get the Input Device handler priority and check that it is valid.
* End the command.
*
* If an end-of-line is required but not seen, give an error and skip
* to the beginning og the next line.
* Return the type of command that we expect next.
*/
static int ContinueCommand(theCommand)
int theCommand;
{
int EndOfLine = TRUE;
switch(theCommand)
{
case COM_ICONKEY:
EndOfLine = ReadKeyDef(&IconifyKey,&IconifyQuals,&IconifyDisquals);
if (EndOfLine) theCommand = COM_NONE;
break;
case COM_CHANGEREFRESH:
ReadKeyDef(NULL,&IconifyChange,NULL);
EndOfLine = FALSE;
break;
case COM_ACTIVEKEY:
EndOfLine = ReadKeyDef(&ActivateKey,&ActivateQuals,NULL);
if (EndOfLine) theCommand = COM_NONE;
break;
case COM_COLORMAP:
ReadColor(ColorID++);
break;
case COM_DEFAULTFLAGS:
ReadIconFlags(&DefaultFlags);
EndOfLine = FALSE;
break;
case COM_SCREENFLAGS:
ReadIconFlags(&DefaultScreenFlags);
EndOfLine = FALSE;
break;
case COM_MENUKEYS:
ReadMenuKey(); NoMenus = FALSE;
break;
case COM_IGNORESCREEN:
ReadIgnoreScreen();
ScreenCount++;
break;
case COM_PRIORITY:
ReadInteger(&IconifyPriority);
if (IconifyPriority < -128 || IconifyPriority > 127)
ShowError("Priority must be in the range -128 to 127"),
IconifyPriority = 0;
theCommand = COM_NONE;
break;
case COM_HIRESCLICOM:
ReadString(&HiResCLICommand);
theCommand = COM_NONE;
break;
case COM_LORESCLICOM:
ReadString(&LoResCLICommand);
theCommand = COM_NONE;
break;
case COM_COMMANDSTACK:
ReadInteger(&StackSize);
if (StackSize < 2000)
ShowError("Stack size must be at least 2K");
StackSize = 2*1024;
theCommand = COM_NONE;
break;
case COM_DEFAULTIMAGE:
case COM_DEFAULTSELECT:
case COM_DEFAULTMASK:
case COM_SCREENIMAGE:
case COM_SCREENSELECT:
case COM_SCREENMASK:
ReadImageLine(BitMapLine++);
break;
case COM_DEAFULTICON:
ReadIconFile(COM_DEFAULTIMAGE);
theCommand = COM_NONE;
EndOfLine = FALSE;
break;
case COM_SCREENICON:
ReadIconFile(COM_SCREENIMAGE);
theCommand = COM_NONE;
EndOfLine = FALSE;
break;
case COM_OPENON:
ReadOpenOn();
theCommand = COM_NONE;
break;
case COM_AUTORESIZE:
ReadBool(&AutoResize);
theCommand = COM_NONE;
break;
case COM_HANDLERPRI:
ReadInteger(&HandlerPriority);
if (HandlerPriority < 51 || HandlerPriority > 127)
ShowError("Priority must be in the range 51 to 127"),
HandlerPriority = 51;
theCommand = COM_NONE;
break;
}
if (EndOfLine && NextChar != '\n')
{
ReadNextWord();
ShowError("'%s' seen where End-of-Line was expected",Word);
SkipLine();
}
return(theCommand);
}
/*
* EndCommand()
*
* Finish the command that is in progress, and check that all parameters,
* etc, have been included. If not, give a message about what was
* expected to be seen. For the image commands, copy the image to the
* correct image pointer.
*/
static void EndCommand(theCommand,newCommand)
int theCommand,newCommand;
{
char *Wanted = NULL;
switch(theCommand)
{
case COM_ICONKEY:
if (IconifyKey == 0) Wanted = "a KEY or BUTTON definition";
break;
case COM_ACTIVEKEY:
if (ActivateKey == 0) Wanted = "a KEY or BUTTON definition";
break;
case COM_COLORMAP:
if (ColorID == 0) Wanted = "an RGB Color";
break;
case COM_MENUKEYS:
if (NoMenus) Wanted = "a Menu Item Name";
break;
case COM_IGNORESCREEN:
if (ScreenCount == 0) Wanted = "a Screen Title";
break;
case COM_PRIORITY:
case COM_COMMANDSTACK:
case COM_HANDLERPRI:
Wanted = "a Number";
break;
case COM_HIRESCLICOM:
case COM_LORESCLICOM:
Wanted = "a CLI Command";
break;
case COM_DEFAULTIMAGE:
if (BitMapLine == 0)
Wanted = "Image Data";
else
SetImage(&DefaultImage);
break;
case COM_DEFAULTSELECT:
if (BitMapLine == 0)
Wanted = "Image Data";
else
SetImage(&DefaultSelect);
break;
case COM_DEFAULTMASK:
if (BitMapLine == 0)
Wanted = "Mask Data";
else
SetImage(&DefaultMask);
break;
case COM_SCREENIMAGE:
if (BitMapLine == 0)
Wanted = "Image Data";
else
SetImage(&DefaultScreenImage);
break;
case COM_SCREENSELECT:
if (BitMapLine == 0)
Wanted = "Image Data";
else
SetImage(&DefaultScreenSelect);
break;
case COM_SCREENMASK:
if (BitMapLine == 0)
Wanted = "Mask Data";
else
SetImage(&DefaultScreenMask);
break;
case COM_DEAFULTICON:
case COM_SCREENICON:
Wanted = "a File Name";
break;
case COM_OPENON:
Wanted = "ACTIVE_SCREEN, CURRENT_WB, or REAL_WB";
break;
case COM_AUTORESIZE:
Wanted = "TRUE or FALSE";
break;
}
if (Wanted)
{
if (newCommand > COM_LAST) Expected(Wanted); else
ShowError("Keyword '%s' seen where %s was expected",
ComName[newCommand],Wanted);
}
}
/*
* ReadFile()
*
* While there is more data in the file,
* Read the next word from the file and interpret it as a command
* If the word was a command and there is an old command in progress
* End the old command
* If the new command is
* Not a command:
* If there is a command in progress, do it to the current word,
* Otherwise give an error and skip to the next line.
* Unknown:
* Give a message and skip to the next line.
* An End-Of-File:
* If an icon file is currently being read, close it,
* Otherwise set the end-of-file marker to TRUE.
* Anything else (i.e., a legitimate command):
* Mark the command as the old command, and setup whatever is needed.
*/
static void ReadFile(theFile)
APTR theFile;
{
int PendingCommand = COM_NONE;
int NewCommand;
int EOF = FALSE;
while (!EOF)
{
NewCommand = ReadCommand();
if (NewCommand != COM_NONE && PendingCommand != COM_NONE)
EndCommand(PendingCommand,NewCommand), PendingCommand = COM_NONE;
switch(NewCommand)
{
case COM_NONE:
if (PendingCommand != COM_NONE)
PendingCommand = ContinueCommand(PendingCommand);
else
Expected("Command Keyword"),
SkipLine();
break;
case COM_UNKNOWN:
ShowError("Unrecognized Command '%s'",Word);
SkipLine();
break;
case COM_EOF:
if (IconFileOpen) EndIconFile();
else EOF = TRUE;
break;
default:
PendingCommand = NewCommand;
StartCommand(PendingCommand);
break;
}
}
}
/*
* ReadInitFile()
*
* Try to open the primary initialization file,
* If unsuccessful, try the secondary file.
* If a file was openned, read the file and then close it.
*/
void ReadInitFile(Name1,Name2)
char *Name1,*Name2;
{
if (OpenFile(Name1) == FALSE)
{
if (Name2)
OpenFile(Name2);
else
printf("Warning: Can't open initialization file '%s'\n",Name1);
}
if (InFile)
{
ReadFile(InFile);
CloseFile(InFile);
}
}